Termination w.r.t. Q proof of /tmp/tmpS-aRvh/thiemann04.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

Q is empty.

↳ QTRS

  ↳ Overlay + Local Confluence

Q restricted rewrite system:
The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

Q is empty.

The TRS is overlay and locally confluent. By [19] we can switch to innermost.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → UNION(rest(i), h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF4(false, x, y, i, h) → TO(i)
IF3(false, b3, x, y, i, h) → FROM(i)
REACH(x, y, i, h) → TO(i)
REACH(x, y, i, h) → FROM(i)
REACH(x, y, i, h) → EQ(x, y)
REACH(x, y, i, h) → EQ(y, to(i))
IF3(false, b3, x, y, i, h) → REST(i)
IF4(false, x, y, i, h) → OR(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))
REACH(x, y, i, h) → ISEMPTY(i)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
REACH(x, y, i, h) → EQ(x, from(i))
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REST(i)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
UNION(edge(x, y, i), h) → UNION(i, h)
EQ(s(x), s(y)) → EQ(x, y)
IF3(false, b3, x, y, i, h) → TO(i)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF4(false, x, y, i, h) → UNION(rest(i), h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF4(false, x, y, i, h) → TO(i)
IF3(false, b3, x, y, i, h) → FROM(i)
REACH(x, y, i, h) → TO(i)
REACH(x, y, i, h) → FROM(i)
REACH(x, y, i, h) → EQ(x, y)
REACH(x, y, i, h) → EQ(y, to(i))
IF3(false, b3, x, y, i, h) → REST(i)
IF4(false, x, y, i, h) → OR(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))
REACH(x, y, i, h) → ISEMPTY(i)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
REACH(x, y, i, h) → EQ(x, from(i))
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REST(i)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
UNION(edge(x, y, i), h) → UNION(i, h)
EQ(s(x), s(y)) → EQ(x, y)
IF3(false, b3, x, y, i, h) → TO(i)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 3 SCCs with 13 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

R is empty.
The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

UNION(edge(x, y, i), h) → UNION(i, h)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

UNION(edge(x, y, i), h) → UNION(i, h)
The graph contains the following edges 1 > 1, 2 >= 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

R is empty.
The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ(s(x), s(y)) → EQ(x, y)

From the DPs we obtained the following set of size-change graphs:

EQ(s(x), s(y)) → EQ(x, y)
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
or(true, y) → true
or(false, y) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
reach(x, y, i, h) → if1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
if1(true, b1, b2, b3, x, y, i, h) → true
if1(false, b1, b2, b3, x, y, i, h) → if2(b1, b2, b3, x, y, i, h)
if2(true, b2, b3, x, y, i, h) → false
if2(false, b2, b3, x, y, i, h) → if3(b2, b3, x, y, i, h)
if3(false, b3, x, y, i, h) → reach(x, y, rest(i), edge(from(i), to(i), h))
if3(true, b3, x, y, i, h) → if4(b3, x, y, i, h)
if4(true, x, y, i, h) → true
if4(false, x, y, i, h) → or(reach(x, y, rest(i), h), reach(to(i), y, union(rest(i), h), empty))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
or(true, x0)
or(false, x0)
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

or(true, x0)
or(false, x0)
reach(x0, x1, x2, x3)
if1(true, x0, x1, x2, x3, x4, x5, x6)
if1(false, x0, x1, x2, x3, x4, x5, x6)
if2(true, x0, x1, x2, x3, x4, x5)
if2(false, x0, x1, x2, x3, x4, x5)
if3(false, x0, x1, x2, x3, x4)
if3(true, x0, x1, x2, x3, x4)
if4(true, x0, x1, x2, x3)
if4(false, x0, x1, x2, x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule REACH(x, y, i, h) → IF1(eq(x, y), isEmpty(i), eq(x, from(i)), eq(y, to(i)), x, y, i, h) at position [0] we obtained the following new rules:

REACH(0, 0, y2, y3) → IF1(true, isEmpty(y2), eq(0, from(y2)), eq(0, to(y2)), 0, 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, 0, y2, y3) → IF1(true, isEmpty(y2), eq(0, from(y2)), eq(0, to(y2)), 0, 0, y2, y3)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, x, y, i, h) → REACH(to(i), y, union(rest(i), h), empty) at position [0] we obtained the following new rules:

IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(rest(edge(x0, x1, x2)), y3), empty) at position [2,0] we obtained the following new rules:

IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF1(false, b1, b2, b3, x, y, i, h) → IF2(b1, b2, b3, x, y, i, h) we obtained the following new rules:

IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, b2, b3, x, y, i, h) → IF3(b2, b3, x, y, i, h) we obtained the following new rules:

IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h))
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(false, b3, x, y, i, h) → REACH(x, y, rest(i), edge(from(i), to(i), h)) we obtained the following new rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h)
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(true, b3, x, y, i, h) → IF4(b3, x, y, i, h) we obtained the following new rules:

IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, x, y, i, h) → REACH(x, y, rest(i), h)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, x, y, i, h) → REACH(x, y, rest(i), h) we obtained the following new rules:

IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, y0, y1, edge(x0, x1, x2), y3) → REACH(x1, y1, union(x2, y3), empty) we obtained the following new rules:

IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF1(false, y_0, y_2, y_4, s(z0), 0, z1, z2) → IF2(y_0, y_2, y_4, s(z0), 0, z1, z2) we obtained the following new rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule REACH(s(x0), 0, y2, y3) → IF1(false, isEmpty(y2), eq(s(x0), from(y2)), eq(0, to(y2)), s(x0), 0, y2, y3) at position [1] we obtained the following new rules:

REACH(s(y0), 0, empty, y2) → IF1(false, true, eq(s(y0), from(empty)), eq(0, to(empty)), s(y0), 0, empty, y2)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, empty, y2) → IF1(false, true, eq(s(y0), from(empty)), eq(0, to(empty)), s(y0), 0, empty, y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

isEmpty(empty)
isEmpty(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), from(edge(x0, x1, x2))), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2) at position [2,1] we obtained the following new rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, to(edge(x0, x1, x2))), s(y0), 0, edge(x0, x1, x2), y2) at position [3,1] we obtained the following new rules:

REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF3(false, z1, s(z2), 0, z3, z4) → REACH(s(z2), 0, rest(z3), edge(from(z3), to(z3), z4)) at position [2] we obtained the following new rules:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, s(y1), 0, empty, y3) → REACH(s(y1), 0, empty, edge(from(empty), to(empty), y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(false, y0, s(y1), 0, empty, y3) → REACH(s(y1), 0, empty, edge(from(empty), to(empty), y3))

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3)) at position [3,0] we obtained the following new rules:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
from(edge(x, y, i)) → x
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
to(edge(x, y, i)) → y

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

from(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
to(edge(x, y, i)) → y

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, to(edge(x0, x1, x2)), y3)) at position [3,1] we obtained the following new rules:

IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
to(edge(x, y, i)) → y

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

to(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, s(z1), 0, z2, z3) → REACH(s(z1), 0, rest(z2), z3) at position [2] we obtained the following new rules:

IF4(false, s(y0), 0, empty, y2) → REACH(s(y0), 0, empty, y2)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(y0), 0, empty, y2) → REACH(s(y0), 0, empty, y2)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, s(z1), 0, edge(x2, x3, x4), z3) → REACH(x3, 0, union(x4, z3), empty) at position [2] we obtained the following new rules:

IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF1(false, false, x1, x2, s(x3), 0, x4, x5) → IF2(false, x1, x2, s(x3), 0, x4, x5) we obtained the following new rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, z1, z2, s(z3), 0, z4, z5) → IF3(z1, z2, s(z3), 0, z4, z5) we obtained the following new rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)
IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(true, z1, s(z2), 0, z3, z4) → IF4(z1, s(z2), 0, z3, z4) we obtained the following new rules:

IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, s(y0), 0, edge(x0, x1, x2), y2) → REACH(s(y0), 0, x2, y2) we obtained the following new rules:

IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3))
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(false, y0, s(y1), 0, edge(x0, x1, x2), y3) → REACH(s(y1), 0, x2, edge(x0, x1, y3)) we obtained the following new rules:

IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, s(y0), 0, edge(y1, y2, empty), x0) → REACH(y2, 0, x0, empty) we obtained the following new rules:

IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, z0, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF3(z0, z1, s(z2), 0, edge(z3, z4, z5), z6) we obtained the following new rules:

IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6)
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(true, z1, s(z2), 0, edge(z3, z4, z5), z6) → IF4(z1, s(z2), 0, edge(z3, z4, z5), z6) we obtained the following new rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))
IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(x0), 0, edge(x1, s(y_0), empty), edge(y_1, y_2, y_3)) → REACH(s(y_0), 0, edge(y_1, y_2, y_3), empty)

The remaining pairs can at least be oriented weakly.

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(edge(x₁, x₂, x₃)) = x₂ + x₃
POL(empty) = 0
POL(eq(x₁, x₂)) = 0
POL(false) = 0
POL(s(x₁)) = 1
POL(true) = 0
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF3(true, false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), 0, edge(x2, s(y_2), empty), edge(y_3, y_4, y_5))
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ QDPOrderProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(y0), 0, edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, 0, edge(x0, x1, union(x2, x3)), empty)

The remaining pairs can at least be oriented weakly.

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₁ + x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₄ + x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₁ + x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₁ + x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₁ + x₃ + x₄
POL(edge(x₁, x₂, x₃)) = x₂ + x₃
POL(empty) = 0
POL(eq(x₁, x₂)) = 0
POL(false) = 1
POL(s(x₁)) = 1
POL(true) = 1
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ UsableRulesProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ QReductionProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ UsableRulesProof

                                                                                    ↳ QDP

                                                                                      ↳ QReductionProof

                                                                                        ↳ QDP

                                                                                          ↳ Rewriting

                                                                                            ↳ QDP

                                                                                              ↳ Rewriting

                                                                                                ↳ QDP

                                                                                                  ↳ Narrowing

                                                                                                    ↳ QDP

                                                                                                      ↳ DependencyGraphProof

                                                                                                        ↳ QDP

                                                                                                          ↳ Rewriting

                                                                                                            ↳ QDP

                                                                                                              ↳ UsableRulesProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ QReductionProof

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Rewriting

                                                                                                                        ↳ QDP

                                                                                                                          ↳ UsableRulesProof

                                                                                                                            ↳ QDP

                                                                                                                              ↳ QReductionProof

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Narrowing

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Instantiation

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Instantiation

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Instantiation

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ QDPSizeChangeProof

                                                                    ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
eq(0, 0) → true
eq(0, s(x)) → false

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

IF4(false, s(x0), 0, edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(s(x0), 0, edge(y_1, y_2, y_3), x4)
The graph contains the following edges 2 >= 1, 3 >= 2, 4 > 3, 5 >= 4
IF2(false, true, x1, s(x2), 0, edge(x3, x4, x5), x6) → IF3(true, x1, s(x2), 0, edge(x3, x4, x5), x6)
The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6
IF3(true, false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, s(x1), 0, edge(x2, x3, edge(y_3, y_4, y_5)), x5)
The graph contains the following edges 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5
IF1(false, false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, s(z0), 0, edge(z1, z2, z3), z4)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7
IF3(false, x0, s(x1), 0, edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(s(x1), 0, edge(y_1, y_2, y_3), edge(x2, x3, x5))
The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3
IF2(false, false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, s(x2), 0, edge(x3, x4, edge(y_4, y_5, y_6)), x6)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6
REACH(s(y0), 0, edge(x0, x1, x2), y2) → IF1(false, false, eq(s(y0), x0), eq(0, x1), s(y0), 0, edge(x0, x1, x2), y2)
The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF1(false, y_1, y_3, y_5, s(z0), s(z1), z2, z3) → IF2(y_1, y_3, y_5, s(z0), s(z1), z2, z3) we obtained the following new rules:

IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule REACH(s(x0), s(x1), y2, y3) → IF1(eq(x0, x1), isEmpty(y2), eq(s(x0), from(y2)), eq(s(x1), to(y2)), s(x0), s(x1), y2, y3) at position [1] we obtained the following new rules:

REACH(s(y0), s(y1), empty, y3) → IF1(eq(y0, y1), true, eq(s(y0), from(empty)), eq(s(y1), to(empty)), s(y0), s(y1), empty, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
REACH(s(y0), s(y1), empty, y3) → IF1(eq(y0, y1), true, eq(s(y0), from(empty)), eq(s(y1), to(empty)), s(y0), s(y1), empty, y3)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), from(edge(x0, x1, x2))), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3) at position [2,1] we obtained the following new rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), to(edge(x0, x1, x2))), s(y0), s(y1), edge(x0, x1, x2), y3) at position [3,1] we obtained the following new rules:

REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5))
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF3(false, z1, s(z2), s(z3), z4, z5) → REACH(s(z2), s(z3), rest(z4), edge(from(z4), to(z4), z5)) at position [2] we obtained the following new rules:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF3(false, y0, s(y1), s(y2), empty, y4) → REACH(s(y1), s(y2), empty, edge(from(empty), to(empty), y4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF3(false, y0, s(y1), s(y2), empty, y4) → REACH(s(y1), s(y2), empty, edge(from(empty), to(empty), y4))
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y4)) at position [3,0] we obtained the following new rules:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4))
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, to(edge(x0, x1, x2)), y4)) at position [3,1] we obtained the following new rules:

IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, s(z1), s(z2), z3, z4) → REACH(s(z1), s(z2), rest(z3), z4) at position [2] we obtained the following new rules:

IF4(false, s(y0), s(y1), empty, y3) → REACH(s(y0), s(y1), empty, y3)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(y0), s(y1), empty, y3) → REACH(s(y0), s(y1), empty, y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF1(false, false, x1, x2, s(x3), s(x4), x5, x6) → IF2(false, x1, x2, s(x3), s(x4), x5, x6) we obtained the following new rules:

IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, z1, z2, s(z3), s(z4), z5, z6) → IF3(z1, z2, s(z3), s(z4), z5, z6) we obtained the following new rules:

IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(true, z1, s(z2), s(z3), z4, z5) → IF4(z1, s(z2), s(z3), z4, z5) we obtained the following new rules:

IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF1(false, y_0, y_2, y_4, 0, s(z0), z1, z2) → IF2(y_0, y_2, y_4, 0, s(z0), z1, z2) we obtained the following new rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule REACH(0, s(x0), y2, y3) → IF1(false, isEmpty(y2), eq(0, from(y2)), eq(s(x0), to(y2)), 0, s(x0), y2, y3) at position [1] we obtained the following new rules:

REACH(0, s(y0), empty, y2) → IF1(false, true, eq(0, from(empty)), eq(s(y0), to(empty)), 0, s(y0), empty, y2)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
REACH(0, s(y0), empty, y2) → IF1(false, true, eq(0, from(empty)), eq(s(y0), to(empty)), 0, s(y0), empty, y2)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
isEmpty(empty) → true
isEmpty(edge(x, y, i)) → false
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
isEmpty(empty)
isEmpty(edge(x0, x1, x2))
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

isEmpty(empty)
isEmpty(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, from(edge(x0, x1, x2))), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2) at position [2,1] we obtained the following new rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), to(edge(x0, x1, x2))), 0, s(y0), edge(x0, x1, x2), y2) at position [3,1] we obtained the following new rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4))
IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF3(false, z1, 0, s(z2), z3, z4) → REACH(0, s(z2), rest(z3), edge(from(z3), to(z3), z4)) at position [2] we obtained the following new rules:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(false, y0, 0, s(y1), empty, y3) → REACH(0, s(y1), empty, edge(from(empty), to(empty), y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF3(false, y0, 0, s(y1), empty, y3) → REACH(0, s(y1), empty, edge(from(empty), to(empty), y3))
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3))
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(from(edge(x0, x1, x2)), to(edge(x0, x1, x2)), y3)) at position [3,0] we obtained the following new rules:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
from(edge(x, y, i)) → x
to(edge(x, y, i)) → y
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
from(edge(x0, x1, x2))
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

from(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3))

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, to(edge(x0, x1, x2)), y3)) at position [3,1] we obtained the following new rules:

IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

to(edge(x, y, i)) → y
eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))
rest(edge(x, y, i)) → i
rest(empty) → empty

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
to(edge(x0, x1, x2))
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

to(edge(x0, x1, x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, 0, s(z1), edge(x2, x3, x4), z3) → REACH(x3, s(z1), union(x4, z3), empty) at position [2] we obtained the following new rules:

IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty)
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, s(z1), s(z2), edge(x2, x3, x4), z4) → REACH(x3, s(z2), union(x4, z4), empty) at position [2] we obtained the following new rules:

IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF4(false, 0, s(z1), z2, z3) → REACH(0, s(z1), rest(z2), z3) at position [2] we obtained the following new rules:

IF4(false, 0, s(y0), empty, y2) → REACH(0, s(y0), empty, y2)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, 0, s(y0), empty, y2) → REACH(0, s(y0), empty, y2)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
rest(edge(x, y, i)) → i
rest(empty) → empty
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)
rest(edge(x0, x1, x2))
rest(empty)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

rest(edge(x0, x1, x2))
rest(empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5)
IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF1(false, false, x1, x2, 0, s(x3), x4, x5) → IF2(false, x1, x2, 0, s(x3), x4, x5) we obtained the following new rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, z1, z2, 0, s(z3), z4, z5) → IF3(z1, z2, 0, s(z3), z4, z5) we obtained the following new rules:

IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(true, z1, 0, s(z2), z3, z4) → IF4(z1, 0, s(z2), z3, z4) we obtained the following new rules:

IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, s(y0), s(y1), edge(y2, y3, empty), x0) → REACH(y3, s(y1), x0, empty) we obtained the following new rules:

IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF3(z0, z1, s(z2), s(z3), edge(z4, z5, z6), z7) we obtained the following new rules:

IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, s(y0), s(y1), edge(x0, x1, x2), y3) → REACH(s(y0), s(y1), x2, y3) we obtained the following new rules:

IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(false, y0, s(y1), s(y2), edge(x0, x1, x2), y4) → REACH(s(y1), s(y2), x2, edge(x0, x1, y4)) we obtained the following new rules:

IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3))
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(false, y0, 0, s(y1), edge(x0, x1, x2), y3) → REACH(0, s(y1), x2, edge(x0, x1, y3)) we obtained the following new rules:

IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF1(false, false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) → IF2(false, y_1, y_2, s(z0), s(z1), edge(z2, z3, z4), z5) we obtained the following new rules:

IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule REACH(s(y0), s(y1), edge(x0, x1, x2), y3) → IF1(eq(y0, y1), false, eq(s(y0), x0), eq(s(y1), x1), s(y0), s(y1), edge(x0, x1, x2), y3) at position [2] we obtained the following new rules:

REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(y0), edge(y1, y2, empty), x0) → REACH(y2, s(y0), x0, empty) we obtained the following new rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(y0), edge(x0, x1, x2), y2) → REACH(0, s(y0), x2, y2) we obtained the following new rules:

IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(true, z1, s(z2), s(z3), edge(z4, z5, z6), z7) → IF4(z1, s(z2), s(z3), edge(z4, z5, z6), z7) we obtained the following new rules:

IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, z0, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF3(z0, z1, 0, s(z2), edge(z3, z4, z5), z6) we obtained the following new rules:

IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(true, z1, 0, s(z2), edge(z3, z4, z5), z6) → IF4(z1, 0, s(z2), edge(z3, z4, z5), z6) we obtained the following new rules:

IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
IF3(true, false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF3(true, false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4))
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, 0, s(x0), edge(x1, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x0), edge(y_1, y_2, y_3), empty)
IF4(false, s(x0), s(x1), edge(x2, 0, empty), edge(y_1, y_2, y_3)) → REACH(0, s(x1), edge(y_1, y_2, y_3), empty)

The remaining pairs can at least be oriented weakly.

IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF3(true, false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4))
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(edge(x₁, x₂, x₃)) = x₂ + x₃
POL(empty) = 0
POL(eq(x₁, x₂)) = 0
POL(false) = 0
POL(s(x₁)) = 0
POL(true) = 0
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF3(true, false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, 0, empty), edge(y_2, y_3, y_4))
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5)) → IF4(false, s(x1), s(x2), edge(x3, 0, empty), edge(y_3, y_4, y_5))
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, s(x0), s(x1), edge(x2, s(y_0), empty), edge(y_2, y_3, y_4)) → REACH(s(y_0), s(x1), edge(y_2, y_3, y_4), empty)
IF4(false, 0, s(x0), edge(x1, x2, edge(y_1, y_2, y_3)), x4) → REACH(0, s(x0), edge(y_1, y_2, y_3), x4)
IF4(false, s(x0), s(x1), edge(x2, x3, edge(y_2, y_3, y_4)), x5) → REACH(s(x0), s(x1), edge(y_2, y_3, y_4), x5)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(s(y_2), y_3, y_4)) → REACH(s(y_0), s(x0), edge(s(y_2), y_3, y_4), empty)
IF4(false, 0, s(x0), edge(x1, s(y_0), empty), edge(0, y_2, y_3)) → REACH(s(y_0), s(x0), edge(0, y_2, y_3), empty)

The remaining pairs can at least be oriented weakly.

IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(edge(x₁, x₂, x₃)) = 1 + x₃
POL(empty) = 1
POL(eq(x₁, x₂)) = 0
POL(false) = 0
POL(s(x₁)) = 0
POL(true) = 0
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(0, y_3, y_4))
IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF3(true, false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5)) → IF4(false, 0, s(x1), edge(x2, s(y_2), empty), edge(s(y_3), y_4, y_5))
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6)) → IF4(false, s(x1), s(x2), edge(x3, s(y_3), empty), edge(y_4, y_5, y_6))
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF3(true, false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF4(false, s(x1), s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)

The remaining pairs can at least be oriented weakly.

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₅ + x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₄ + x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₃ + x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₁ + x₃ + x₄
POL(edge(x₁, x₂, x₃)) = x₂ + x₃
POL(empty) = 0
POL(eq(x₁, x₂)) = 0
POL(false) = 0
POL(s(x₁)) = 1
POL(true) = 0
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, s(y0), s(y1), edge(y2, y3, edge(x0, x1, x2)), x3) → REACH(y3, s(y1), edge(x0, x1, union(x2, x3)), empty)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF1(false, false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, true, x1, s(x2), s(x3), edge(x4, x5, x6), x7)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                                                                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                                                                                                                                                                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                                ↳ QDPSizeChangeProof

                                                                                                                                                                                                                                                                                                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

IF1(false, false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 1, 1 >= 2, 2 >= 2, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7
IF3(false, x0, s(x1), s(x2), edge(x3, x4, edge(y_2, y_3, y_4)), x6) → REACH(s(x1), s(x2), edge(y_2, y_3, y_4), edge(x3, x4, x6))
The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3
IF2(false, false, x1, s(x2), s(x3), edge(x4, x5, x6), x7) → IF3(false, x1, s(x2), s(x3), edge(x4, x5, x6), x7)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6
REACH(s(x0), s(y1), edge(0, y3, y4), y5) → IF1(eq(x0, y1), false, false, eq(s(y1), y3), s(x0), s(y1), edge(0, y3, y4), y5)
The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8
REACH(s(x0), s(y1), edge(s(x1), y3, y4), y5) → IF1(eq(x0, y1), false, eq(x0, x1), eq(s(y1), y3), s(x0), s(y1), edge(s(x1), y3, y4), y5)
The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)
IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, 0, s(y0), edge(y1, y2, edge(x0, x1, x2)), x3) → REACH(y2, s(y0), edge(x0, x1, union(x2, x3)), empty)

The remaining pairs can at least be oriented weakly.

IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(IF1(x₁, x₂, x₃, x₄, x₅, x₆, x₇, x₈)) = x₇ + x₈
POL(IF2(x₁, x₂, x₃, x₄, x₅, x₆, x₇)) = x₆ + x₇
POL(IF3(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆
POL(IF4(x₁, x₂, x₃, x₄, x₅)) = x₄ + x₅
POL(REACH(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(edge(x₁, x₂, x₃)) = 1 + x₃
POL(empty) = 0
POL(eq(x₁, x₂)) = 0
POL(false) = 0
POL(s(x₁)) = 0
POL(true) = 0
POL(union(x₁, x₂)) = x₁ + x₂

The following usable rules [17] were oriented:

union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(true, false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5) → IF4(false, 0, s(x1), edge(x2, x3, edge(y_3, y_4, y_5)), x5)
IF2(false, true, x1, 0, s(x2), edge(x3, x4, x5), x6) → IF3(true, x1, 0, s(x2), edge(x3, x4, x5), x6)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)
union(empty, h) → h
union(edge(x, y, i), h) → edge(x, y, union(i, h))

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                                                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))
union(empty, x0)
union(edge(x0, x1, x2), x3)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

union(empty, x0)
union(edge(x0, x1, x2), x3)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ DependencyGraphProof

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Instantiation

                                          ↳ QDP

                                            ↳ Instantiation

                                              ↳ QDP

                                                ↳ Instantiation

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ DependencyGraphProof

                                                                  ↳ AND

                                                                    ↳ QDP

                                                                    ↳ QDP

                                                                      ↳ ForwardInstantiation

                                                                        ↳ QDP

                                                                          ↳ Narrowing

                                                                            ↳ QDP

                                                                              ↳ DependencyGraphProof

                                                                                ↳ QDP

                                                                                  ↳ Rewriting

                                                                                    ↳ QDP

                                                                                      ↳ Rewriting

                                                                                        ↳ QDP

                                                                                          ↳ Narrowing

                                                                                            ↳ QDP

                                                                                              ↳ DependencyGraphProof

                                                                                                ↳ QDP

                                                                                                  ↳ Rewriting

                                                                                                    ↳ QDP

                                                                                                      ↳ Rewriting

                                                                                                        ↳ QDP

                                                                                                          ↳ Narrowing

                                                                                                            ↳ QDP

                                                                                                              ↳ DependencyGraphProof

                                                                                                                ↳ QDP

                                                                                                                  ↳ Instantiation

                                                                                                                    ↳ QDP

                                                                                                                      ↳ Instantiation

                                                                                                                        ↳ QDP

                                                                                                                          ↳ Instantiation

                                                                                                                            ↳ QDP

                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Narrowing

                                                                                                                                    ↳ QDP

                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                        ↳ QDP

                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                            ↳ QDP

                                                                                                                                              ↳ QReductionProof

                                                                                                                                                ↳ QDP

                                                                                                                                                  ↳ Rewriting

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ Rewriting

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ Narrowing

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ DependencyGraphProof

                                                                                                                                                                ↳ QDP

                                                                                                                                                                  ↳ Rewriting

                                                                                                                                                                    ↳ QDP

                                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                                        ↳ QDP

                                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                                            ↳ QDP

                                                                                                                                                                              ↳ Rewriting

                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                  ↳ UsableRulesProof

                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                      ↳ QReductionProof

                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                          ↳ Narrowing

                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                              ↳ Narrowing

                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                  ↳ Narrowing

                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                      ↳ DependencyGraphProof

                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                          ↳ UsableRulesProof

                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                              ↳ QReductionProof

                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                  ↳ Instantiation

                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                      ↳ Instantiation

                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                          ↳ Instantiation

                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                      ↳ Narrowing

                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                              ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                    ↳ QDP

                                                                                                                                                                                                                                                                                      ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                                          ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                    ↳ AND

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                        ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                                                                            ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                                                                    ↳ QReductionProof

                                                                                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                                                                                        ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))

The TRS R consists of the following rules:

eq(0, 0) → true
eq(0, s(x)) → false
eq(s(x), 0) → false
eq(s(x), s(y)) → eq(x, y)

The set Q consists of the following terms:

eq(0, 0)
eq(0, s(x0))
eq(s(x0), 0)
eq(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

IF2(false, false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6) → IF3(false, x1, 0, s(x2), edge(x3, x4, edge(y_4, y_5, y_6)), x6)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6
REACH(0, s(y0), edge(x0, x1, x2), y2) → IF1(false, false, eq(0, x0), eq(s(y0), x1), 0, s(y0), edge(x0, x1, x2), y2)
The graph contains the following edges 1 >= 5, 2 >= 6, 3 >= 7, 4 >= 8
IF1(false, false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4) → IF2(false, y_0, y_1, 0, s(z0), edge(z1, z2, z3), z4)
The graph contains the following edges 1 >= 1, 2 >= 1, 3 >= 2, 4 >= 3, 5 >= 4, 6 >= 5, 7 >= 6, 8 >= 7
IF3(false, x0, 0, s(x1), edge(x2, x3, edge(y_1, y_2, y_3)), x5) → REACH(0, s(x1), edge(y_1, y_2, y_3), edge(x2, x3, x5))
The graph contains the following edges 3 >= 1, 4 >= 2, 5 > 3